package js;

import java.util.Scanner;

public class q子矩阵 {
    public static void main(String[] args) {
        Solution();
    }
    /**
     * 方法二，优化
     */
    static void Solution(){
        // 在Solution1基础上考虑优化，每次右移动子矩阵时，只需要用多出的那一部分 去比较 上一个子矩阵的最值
        // 当下移动时再计算整个子矩阵
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int a = scan.nextInt();
        int b = scan.nextInt();
        int[][] matrix = new int[n][m];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                matrix[i][j] = scan.nextInt();
            }
        }
        scan.close();
        long ans = 0;
        int flag = 1;
        int minCol = 0;
        int maxCol = 0;

        for(int i = 0; i < n - a + 1; i++) {
            long min = Long.MAX_VALUE;
            long max = 0;
            for(int j = 0; j < m - b + 1; j++) {
                if(flag ==1 || minCol<j || maxCol<j){ // 首次进入这一行时，初始化
                    min = matrix[i][j];
                    max = matrix[i][j];
                    // i更新的标识
                    for(int k = i; k < i + a; k++) {
                        for(int l = j; l < j + b; l++) {

                            if(min > matrix[k][l]){
                                minCol = l;
                                min = matrix[k][l];
                            }
                            if(max < matrix[k][l]){
                                maxCol = l;
                                max = matrix[k][l];
                            }

                        }
                    }
                    flag = 0;
                }else{
                    // 每次右移动子矩阵时，只需要用多出的那一列 去比较 上一个子矩阵的最值
                    for(int k = i; k < i + a; k++) {
                        if(min > matrix[k][j + b -1]){
                            minCol = j + b -1;
                            min = matrix[k][j + b -1];
                        }
                        if(max < matrix[k][j + b -1]){
                            maxCol = j + b -1;
                            max = matrix[k][j + b -1];
                        }

                    }
                }
                System.out.println("min = " + min + " max = " + max);
                ans = (ans + max * min) % 998244353;
            }
            flag = 1;
        }
        System.out.println(ans);
    }


    /**
     * 方法一，纯暴力
     */
    static void Solution1(){

        //输入的第一行包含四个整数分别表示n，m, a，b，相邻整数之间使用一个空格分隔。接下来
        //n行每行包含m个整数，相邻整数之间使用一个空格分隔，表示矩阵中的每个数Ai,j。
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int a = scan.nextInt();
        int b = scan.nextInt();
        int[][] matrix = new int[n][m];
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                matrix[i][j] = scan.nextInt();
            }
        }
        scan.close();
        long ans = 0;
        //矩阵的价值为其所有数中的最大值和最小值的乘积。求给定矩阵的所有大小为a ×b (a行b列)的子矩阵的价值的和。
        //答案可能很大，你只需要输出答案对998244353取模后的结果。
        for(int i = 0; i < n - a + 1; i++) {
            for(int j = 0; j < m - b + 1; j++) {
                long min = matrix[i][j];
                long max = matrix[i][j];
                for(int k = i; k < i + a; k++) {
                    for(int l = j; l < j + b; l++) {
                        min = Math.min(min, matrix[k][l]);
                        max = Math.max(max, matrix[k][l]);
                    }
                }
                ans = (ans + max * min) % 998244353;
            }
        }
        System.out.println(ans);
    }


}
